home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / gdb / gdb_18s.zoo / valarith.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-25  |  10.7 KB  |  479 lines
  1. /* Perform arithmetic and other operations on values, for GDB.
  2.    Copyright (C) 1986 Free Software Foundation, Inc.
  3.  
  4. GDB is distributed in the hope that it will be useful, but WITHOUT ANY
  5. WARRANTY.  No author or distributor accepts responsibility to anyone
  6. for the consequences of using it or for whether it serves any
  7. particular purpose or works at all, unless he says so in writing.
  8. Refer to the GDB General Public License for full details.
  9.  
  10. Everyone is granted permission to copy, modify and redistribute GDB,
  11. but only under the conditions described in the GDB General Public
  12. License.  A copy of this license is supposed to have been given to you
  13. along with GDB so you can know your rights and responsibilities.  It
  14. should be in a file named COPYING.  Among other things, the copyright
  15. notice and this notice must be preserved on all copies.
  16.  
  17. In other words, go ahead and share GDB, but don't try to stop
  18. anyone else from sharing it farther.  Help stamp out software hoarding!
  19. */
  20.  
  21. #include "defs.h"
  22. #include "param.h"
  23. #include "symtab.h"
  24. #include "value.h"
  25. #include "expression.h"
  26.  
  27.  
  28. value
  29. value_add (arg1, arg2)
  30.     value arg1, arg2;
  31. {
  32.   register value val, valint, valptr;
  33.   register int len;
  34.  
  35.   COERCE_ARRAY (arg1);
  36.   COERCE_ARRAY (arg2);
  37.  
  38.   if ((TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR
  39.        || TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_PTR)
  40.       &&
  41.       (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_INT
  42.        || TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_INT))
  43.     /* Exactly one argument is a pointer, and one is an integer.  */
  44.     {
  45.       if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR)
  46.     {
  47.       valptr = arg1;
  48.       valint = arg2;
  49.     }
  50.       else
  51.     {
  52.       valptr = arg2;
  53.       valint = arg1;
  54.     }
  55.       len = TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (valptr)));
  56.       if (len == 0) len = 1;    /* For (void *) */
  57.       val = value_from_long (builtin_type_long,
  58.                  value_as_long (valptr)
  59.                  + (len * value_as_long (valint)));
  60.       VALUE_TYPE (val) = VALUE_TYPE (valptr);
  61.       return val;
  62.     }
  63.  
  64.   return value_binop (arg1, arg2, BINOP_ADD);
  65. }
  66.  
  67. value
  68. value_sub (arg1, arg2)
  69.     value arg1, arg2;
  70. {
  71.   register value val;
  72.  
  73.   COERCE_ARRAY (arg1);
  74.   COERCE_ARRAY (arg2);
  75.  
  76.   if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR)
  77.     {
  78.       if (TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_INT)
  79.     {
  80.       /* pointer - integer.  */
  81.       val = value_from_long
  82.         (builtin_type_long,
  83.          value_as_long (arg1)
  84.          - (TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)))
  85.         * value_as_long (arg2)));
  86.       VALUE_TYPE (val) = VALUE_TYPE (arg1);
  87.       return val;
  88.     }
  89.       else if (VALUE_TYPE (arg1) == VALUE_TYPE (arg2))
  90.     {
  91.       /* pointer to <type x> - pointer to <type x>.  */
  92.       val = value_from_long
  93.         (builtin_type_long,
  94.          (value_as_long (arg1) - value_as_long (arg2))
  95.          / TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))));
  96.       return val;
  97.     }
  98.       else
  99.     {
  100.       error ("\
  101. First argument of `-' is a pointer and second argument is neither\n\
  102. an integer nor a pointer of the same type.");
  103.     }
  104.     }
  105.  
  106.   return value_binop (arg1, arg2, BINOP_SUB);
  107. }
  108.  
  109. /* Return the value of ARRAY[IDX].  */
  110.  
  111. value
  112. value_subscript (array, idx)
  113.      value array, idx;
  114. {
  115.   return value_ind (value_add (array, idx));
  116. }
  117.  
  118. /* Perform a binary operation on two integers or two floats.
  119.    Does not support addition and subtraction on pointers;
  120.    use value_add or value_sub if you want to handle those possibilities.  */
  121.  
  122. value
  123. value_binop (arg1, arg2, op)
  124.      value arg1, arg2;
  125.      int op;
  126. {
  127.   register value val;
  128.  
  129.   COERCE_ENUM (arg1);
  130.   COERCE_ENUM (arg2);
  131.  
  132.   if ((TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_FLT
  133.        &&
  134.        TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_INT)
  135.       ||
  136.       (TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_FLT
  137.        &&
  138.        TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_INT))
  139.     error ("Argument to arithmetic operation not a number.");
  140.  
  141.   if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_FLT
  142.       ||
  143.       TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_FLT)
  144.     {
  145.       double v1, v2, v;
  146.       v1 = value_as_double (arg1);
  147.       v2 = value_as_double (arg2);
  148.       switch (op)
  149.     {
  150.     case BINOP_ADD:
  151.       v = v1 + v2;
  152.       break;
  153.  
  154.     case BINOP_SUB:
  155.       v = v1 - v2;
  156.       break;
  157.  
  158.     case BINOP_MUL:
  159.       v = v1 * v2;
  160.       break;
  161.  
  162.     case BINOP_DIV:
  163.       v = v1 / v2;
  164.       break;
  165.  
  166.     default:
  167.       error ("Integer-only operation on floating point number.");
  168.     }
  169.  
  170.       val = allocate_value (builtin_type_double);
  171.       *(double *) VALUE_CONTENTS (val) = v;
  172.     }
  173.   else
  174.     /* Integral operations here.  */
  175.     {
  176.       /* Should we promote to unsigned longest?  */
  177.       if ((TYPE_UNSIGNED (VALUE_TYPE (arg1))
  178.        || TYPE_UNSIGNED (VALUE_TYPE (arg2)))
  179.       && (TYPE_LENGTH (VALUE_TYPE (arg1)) >= sizeof (unsigned long)
  180.           || TYPE_LENGTH (VALUE_TYPE (arg1)) >= sizeof (unsigned long)))
  181.     {
  182.       unsigned long v1, v2, v;
  183.       v1 = (unsigned long) value_as_long (arg1);
  184.       v2 = (unsigned long) value_as_long (arg2);
  185.       
  186.       switch (op)
  187.         {
  188.         case BINOP_ADD:
  189.           v = v1 + v2;
  190.           break;
  191.           
  192.         case BINOP_SUB:
  193.           v = v1 - v2;
  194.           break;
  195.           
  196.         case BINOP_MUL:
  197.           v = v1 * v2;
  198.           break;
  199.           
  200.         case BINOP_DIV:
  201.           v = v1 / v2;
  202.           break;
  203.           
  204.         case BINOP_REM:
  205.           v = v1 % v2;
  206.           break;
  207.           
  208.         case BINOP_LSH:
  209.           v = v1 << v2;
  210.           break;
  211.           
  212.         case BINOP_RSH:
  213.           v = v1 >> v2;
  214.           break;
  215.           
  216.         case BINOP_LOGAND:
  217.           v = v1 & v2;
  218.           break;
  219.           
  220.         case BINOP_LOGIOR:
  221.           v = v1 | v2;
  222.           break;
  223.           
  224.         case BINOP_LOGXOR:
  225.           v = v1 ^ v2;
  226.           break;
  227.           
  228.         case BINOP_AND:
  229.           v = v1 && v2;
  230.           break;
  231.           
  232.         case BINOP_OR:
  233.           v = v1 || v2;
  234.           break;
  235.           
  236. #if 0
  237.         case BINOP_MIN:
  238.           v = v1 < v2 ? v1 : v2;
  239.           break;
  240.           
  241.         case BINOP_MAX:
  242.           v = v1 > v2 ? v1 : v2;
  243.           break;
  244. #endif
  245.           
  246.         default:
  247.           error ("Invalid binary operation on numbers.");
  248.         }
  249.  
  250.       val = allocate_value (builtin_type_unsigned_long);
  251.       *(unsigned long *) VALUE_CONTENTS_RAW (val) = v;
  252.     }
  253.       else
  254.     {
  255.       long v1, v2, v;
  256.       v1 = value_as_long (arg1);
  257.       v2 = value_as_long (arg2);
  258.       
  259.       switch (op)
  260.         {
  261.         case BINOP_ADD:
  262.           v = v1 + v2;
  263.           break;
  264.           
  265.         case BINOP_SUB:
  266.           v = v1 - v2;
  267.           break;
  268.           
  269.         case BINOP_MUL:
  270.           v = v1 * v2;
  271.           break;
  272.           
  273.         case BINOP_DIV:
  274.           v = v1 / v2;
  275.           break;
  276.           
  277.         case BINOP_REM:
  278.           v = v1 % v2;
  279.           break;
  280.           
  281.         case BINOP_LSH:
  282.           v = v1 << v2;
  283.           break;
  284.           
  285.         case BINOP_RSH:
  286.           v = v1 >> v2;
  287.           break;
  288.           
  289.         case BINOP_LOGAND:
  290.           v = v1 & v2;
  291.           break;
  292.           
  293.         case BINOP_LOGIOR:
  294.           v = v1 | v2;
  295.           break;
  296.           
  297.         case BINOP_LOGXOR:
  298.           v = v1 ^ v2;
  299.           break;
  300.           
  301.         case BINOP_AND:
  302.           v = v1 && v2;
  303.           break;
  304.           
  305.         case BINOP_OR:
  306.           v = v1 || v2;
  307.           break;
  308.           
  309. #if 0
  310.         case BINOP_MIN:
  311.           v = v1 < v2 ? v1 : v2;
  312.           break;
  313.           
  314.         case BINOP_MAX:
  315.           v = v1 > v2 ? v1 : v2;
  316.           break;
  317. #endif
  318.           
  319.         default:
  320.           error ("Invalid binary operation on numbers.");
  321.         }
  322.       
  323.       val = allocate_value (builtin_type_long);
  324.       *(long *) VALUE_CONTENTS_RAW (val) = v;
  325.     }
  326.     }
  327.  
  328.   return val;
  329. }
  330.  
  331. /* Simulate the C operator ! -- return 1 if ARG1 contains zeros.  */
  332.  
  333. int
  334. value_zerop (arg1)
  335.      value arg1;
  336. {
  337.   register int len;
  338.   register char *p;
  339.  
  340.   COERCE_ARRAY (arg1);
  341.  
  342.   len = TYPE_LENGTH (VALUE_TYPE (arg1));
  343.   p = VALUE_CONTENTS (arg1);
  344.  
  345.   while (--len >= 0)
  346.     {
  347.       if (*p++)
  348.     break;
  349.     }
  350.  
  351.   return len < 0;
  352. }
  353.  
  354. /* Simulate the C operator == by returning a 1
  355.    iff ARG1 and ARG2 have equal contents.  */
  356.  
  357. int
  358. value_equal (arg1, arg2)
  359.      register value arg1, arg2;
  360.  
  361. {
  362.   register int len;
  363.   register char *p1, *p2;
  364.   enum type_code code1;
  365.   enum type_code code2;
  366.  
  367.   COERCE_ARRAY (arg1);
  368.   COERCE_ARRAY (arg2);
  369.  
  370.   code1 = TYPE_CODE (VALUE_TYPE (arg1));
  371.   code2 = TYPE_CODE (VALUE_TYPE (arg2));
  372.  
  373.   if (code1 == TYPE_CODE_INT && code2 == TYPE_CODE_INT)
  374.     return value_as_long (arg1) == value_as_long (arg2);
  375.   else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT)
  376.        && (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT))
  377.     return value_as_double (arg1) == value_as_double (arg2);
  378.   else if ((code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_INT)
  379.        || (code2 == TYPE_CODE_PTR && code1 == TYPE_CODE_INT))
  380.     return value_as_long (arg1) == value_as_long (arg2);
  381.   else if (code1 == code2
  382.        && ((len = TYPE_LENGTH (VALUE_TYPE (arg1)))
  383.            == TYPE_LENGTH (VALUE_TYPE (arg2))))
  384.     {
  385.       p1 = VALUE_CONTENTS (arg1);
  386.       p2 = VALUE_CONTENTS (arg2);
  387.       while (--len >= 0)
  388.     {
  389.       if (*p1++ != *p2++)
  390.         break;
  391.     }
  392.       return len < 0;
  393.     }
  394.   else
  395.     error ("Invalid type combination in equality test.");
  396. }
  397.  
  398. /* Simulate the C operator < by returning 1
  399.    iff ARG1's contents are less than ARG2's.  */
  400.  
  401. int
  402. value_less (arg1, arg2)
  403.      register value arg1, arg2;
  404. {
  405.   register enum type_code code1;
  406.   register enum type_code code2;
  407.  
  408.   COERCE_ARRAY (arg1);
  409.   COERCE_ARRAY (arg2);
  410.  
  411.   code1 = TYPE_CODE (VALUE_TYPE (arg1));
  412.   code2 = TYPE_CODE (VALUE_TYPE (arg2));
  413.  
  414.   if (code1 == TYPE_CODE_INT && code2 == TYPE_CODE_INT)
  415.     {
  416.       if (TYPE_UNSIGNED (VALUE_TYPE (arg1))
  417.        || TYPE_UNSIGNED (VALUE_TYPE (arg2)))
  418.     return ((unsigned long) value_as_long (arg1)
  419.         < (unsigned long) value_as_long (arg2));
  420.       else
  421.     return value_as_long (arg1) < value_as_long (arg2);
  422.     }
  423.   else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT)
  424.        && (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT))
  425.     return value_as_double (arg1) < value_as_double (arg2);
  426.   else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
  427.     return value_as_long (arg1) < value_as_long (arg2);
  428.  
  429.   /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
  430.      is bigger.  */
  431.   else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_INT)
  432.     return value_as_long (arg1) < (CORE_ADDR) value_as_long (arg2);
  433.   else if (code2 == TYPE_CODE_PTR && code1 == TYPE_CODE_INT)
  434.     return (CORE_ADDR) value_as_long (arg1) < value_as_long (arg2);
  435.  
  436.   else
  437.     {
  438.       error ("Invalid type combination in ordering comparison.");
  439.       return 0;
  440.     }
  441. }
  442.  
  443. /* The unary operators - and ~.  Both free the argument ARG1.  */
  444.  
  445. value
  446. value_neg (arg1)
  447.      register value arg1;
  448. {
  449.   register struct type *type;
  450.  
  451.   COERCE_ENUM (arg1);
  452.  
  453.   type = VALUE_TYPE (arg1);
  454.  
  455.   if (TYPE_CODE (type) == TYPE_CODE_FLT)
  456.     return value_from_double (type, - value_as_double (arg1));
  457.   else if (TYPE_CODE (type) == TYPE_CODE_INT)
  458.     return value_from_long (type, - value_as_long (arg1));
  459.   else
  460.     error ("Argument to negate operation not a number.");
  461. }
  462.  
  463. value
  464. value_lognot (arg1)
  465.      register value arg1;
  466. {
  467.   COERCE_ENUM (arg1);
  468.  
  469.   if (TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_INT)
  470.     error ("Argument to complement operation not an integer.");
  471.  
  472.   return value_from_long (VALUE_TYPE (arg1), ~ value_as_long (arg1));
  473. }
  474.  
  475. void
  476. initialize_valarith ()
  477. {
  478. }
  479.